package user

import (
	"fmt"
	"io"
	"os/exec"
	"runtime"
	"sort"
	"strings"

	"gitee.com/liumou_site/gcs"
	"gitee.com/liumou_site/logger"
	"golang.org/x/text/encoding/simplifiedchinese"
	"golang.org/x/text/transform"
)

// SystemUser 系统用户信息结构体
type SystemUser struct {
	Username string // 用户名
	UID      string // 用户ID
	GID      string // 组ID
	Home     string // 主目录
	Shell    string // 登录shell
	IsSystem bool   // 是否为系统用户
}

// ListSystemUsers 获取当前系统支持登录的用户列表
// 返回按用户名排序的用户列表
func ListSystemUsers() ([]SystemUser, error) {
	if runtime.GOOS == "windows" {
		return listWindowsUsers()
	}
	return listLinuxUsers()
}

// listWindowsUsers 获取Windows系统用户列表
func listWindowsUsers() ([]SystemUser, error) {
	var users []SystemUser

	logger.Info("正在获取Windows系统用户列表...")

	// 使用net user命令获取用户列表
	cmd := exec.Command("net", "user")
	// 设置GBK编码输出捕获
	stdout, err := cmd.StdoutPipe()
	if err != nil {
		logger.Error("创建命令管道失败: %v", err)
		return nil, fmt.Errorf("创建管道失败: %v", err)
	}

	if err = cmd.Start(); err != nil {
		logger.Error("启动net user命令失败: %v", err)
		return nil, fmt.Errorf("启动命令失败: %v", err)
	}

	// 读取GBK编码的输出
	reader := transform.NewReader(stdout, simplifiedchinese.GBK.NewDecoder())
	output, err := io.ReadAll(reader)
	if err != nil {
		logger.Error("执行命令失败:", err)
		return nil, fmt.Errorf("执行命令失败: %v", err)
	}

	if err := cmd.Wait(); err != nil {
		logger.Error("net user命令执行失败: %v", err)
		return nil, fmt.Errorf("命令执行失败: %v", err)
	}

	outputStr := string(output)
	lines := strings.Split(outputStr, "\n")
	var userSection bool

	userCount := 0
	for _, line := range lines {
		line = strings.TrimSpace(line)

		if line == "" {
			continue
		}

		// 跳过标题行（支持中英文Windows系统）
		if strings.Contains(line, "User accounts for") || strings.Contains(line, "用户帐户") {
			continue
		}

		// 跳过分隔线，开始用户区域
		if strings.HasPrefix(line, "-----") {
			userSection = true
			continue
		}

		// 跳过命令提示（支持中英文Windows系统）
		if strings.Contains(line, "The command completed") || strings.Contains(line, "命令成功完成") {
			break
		}

		if userSection {
			// 解析用户列表行（可能包含多个用户名）
			fields := strings.Fields(line)
			for _, username := range fields {
				username = strings.TrimSpace(username)
				if username != "" && !isWindowsSystemUser(username) {
					users = append(users, SystemUser{
						Username: username,
						IsSystem: false,
					})
					userCount++
				}
			}
		}
	}

	// 按用户名排序
	sort.Slice(users, func(i, j int) bool {
		return users[i].Username < users[j].Username
	})

	logger.Info("成功获取Windows系统用户，共找到 %d 个可添加的用户", userCount)
	if userCount == 0 {
		logger.Warn("当前系统没有可添加的登录用户")
	}

	return users, nil
}

// listLinuxUsers 获取Linux系统支持登录的用户列表
func listLinuxUsers() ([]SystemUser, error) {
	var users []SystemUser

	logger.Info("正在获取Linux系统用户列表...")

	// 使用getent passwd获取所有用户信息
	shell := gcs.NewShell()
	shell.RunShell("getent", "passwd")

	if shell.Err != nil {
		logger.Error("获取Linux用户列表失败:", shell.Err)
		return nil, fmt.Errorf("获取Linux用户列表失败: %v", shell.Err)
	}

	lines := strings.Split(shell.Strings, "\n")
	userCount := 0

	for _, line := range lines {
		line = strings.TrimSpace(line)
		if line == "" {
			continue
		}

		parts := strings.Split(line, ":")
		if len(parts) < 7 {
			continue
		}

		username := parts[0]
		uid := parts[2]
		gid := parts[3]
		home := parts[5]
		shellPath := parts[6]

		// 检查是否为有效登录用户
		if isValidLinuxLoginUser(username, uid, shellPath) {
			users = append(users, SystemUser{
				Username: username,
				UID:      uid,
				GID:      gid,
				Home:     home,
				Shell:    shellPath,
				IsSystem: isLinuxSystemUser(uid),
			})
			userCount++
		}
	}

	// 按用户名排序
	sort.Slice(users, func(i, j int) bool {
		return users[i].Username < users[j].Username
	})

	logger.Info("成功获取Linux系统用户，共找到 %d 个可添加的用户", userCount)
	if userCount == 0 {
		logger.Warn("当前系统没有可添加的登录用户")
	}

	return users, nil
}

// isValidLinuxLoginUser 检查Linux用户是否为有效登录用户
func isValidLinuxLoginUser(username, uid, shellPath string) bool {
	// 排除系统用户（UID < 1000，除了root）
	if uid != "0" && uid != "" {
		// 检查UID是否为数字
		if strings.Contains(uid, "-") {
			return false
		}
		// 排除UID小于1000的非root用户
		if uidInt := 0; false {
			// 简化处理，直接排除常见系统用户
			if uidInt < 1000 && uidInt != 0 {
				return false
			}
		}
	}

	// 检查shell是否为有效登录shell
	invalidShells := []string{
		"/sbin/nologin",
		"/bin/false",
		"/usr/sbin/nologin",
		"/usr/bin/false",
		"/bin/sync",
		"/sbin/shutdown",
		"/sbin/halt",
		"/bin/true",
	}

	for _, invalid := range invalidShells {
		if shellPath == invalid {
			return false
		}
	}

	// 排除常见系统用户名
	systemUsers := map[string]bool{
		"nobody":     true,
		"daemon":     true,
		"bin":        true,
		"sys":        true,
		"sync":       true,
		"games":      true,
		"man":        true,
		"lp":         true,
		"mail":       true,
		"news":       true,
		"uucp":       true,
		"proxy":      true,
		"www-data":   true,
		"backup":     true,
		"list":       true,
		"irc":        true,
		"gnats":      true,
		"systemd":    true,
		"messagebus": true,
		"sshd":       true,
	}

	return !systemUsers[username]
}

// isLinuxSystemUser 判断是否为系统用户
func isLinuxSystemUser(uid string) bool {
	// 系统用户通常UID < 1000，root除外
	if uid == "0" {
		return false // root用户
	}

	// 简化判断，UID小于1000认为是系统用户
	return uid < "1000"
}

// isWindowsSystemUser 判断是否为Windows系统用户
func isWindowsSystemUser(username string) bool {
	// Windows内置系统用户和特殊组
	systemUsers := map[string]bool{
		"DefaultAccount":                  true,
		"Guest":                           true,
		"WDAGUtilityAccount":              true,
		"SYSTEM":                          true,
		"LOCAL SERVICE":                   true,
		"NETWORK SERVICE":                 true,
		"TrustedInstaller":                true,
		"ANONYMOUS LOGON":                 true,
		"CREATOR OWNER":                   true,
		"INTERACTIVE":                     true,
		"Authenticated Users":             true,
		"Everyone":                        true,
		"Users":                           true,
		"Administrators":                  true,
		"Guests":                          true,
		"Power Users":                     true,
		"Backup Operators":                true,
		"Replicator":                      true,
		"Remote Desktop Users":            true,
		"Network Configuration Operators": true,
		"Performance Log Users":           true,
		"Performance Monitor Users":       true,
		"Distributed COM Users":           true,
		"IIS_IUSRS":                       true,
		"IUSR":                            true,
	}

	return systemUsers[username]
}

// GetUserListString 获取格式化的用户列表字符串
func GetUserListString() (string, error) {
	users, err := ListSystemUsers()
	if err != nil {
		return "", err
	}

	if len(users) == 0 {
		return "当前系统没有可添加的登录用户", nil
	}

	var sb strings.Builder

	if runtime.GOOS == "windows" {
		sb.WriteString("Windows系统可添加用户列表:\n")
	} else {
		sb.WriteString("Linux系统可添加用户列表:\n")
	}

	for i, user := range users {
		if runtime.GOOS == "windows" {
			sb.WriteString(fmt.Sprintf("  %d. %s\n", i+1, user.Username))
		} else {
			sb.WriteString(fmt.Sprintf("  %d. %s (UID: %s, Shell: %s)\n",
				i+1, user.Username, user.UID, user.Shell))
		}
	}

	return sb.String(), nil
}
